// This code is derived from jcifs smb client library <jcifs at samba dot org>
// Ported by J. Arturo <webmaster at komodosoft dot net>
//  
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
using System;
using SharpCifs.Util.Sharpen;

namespace SharpCifs.Util
{
    /// <summary>Implements the MD4 message digest algorithm in Java.</summary>
    /// <remarks>
    /// Implements the MD4 message digest algorithm in Java.
    /// <p>
    /// <b>References:</b>
    /// <ol>
    /// <li> Ronald L. Rivest,
    /// "<a href="http://www.roxen.com/rfc/rfc1320.html">
    /// The MD4 Message-Digest Algorithm</a>",
    /// IETF RFC-1320 (informational).
    /// </ol>
    /// <p><b>$Revision: 1.2 $</b>
    /// </remarks>
    /// <author>Raif S. Naffah</author>
    public class Md4 : MessageDigest
    {
        /// <summary>The size in bytes of the input block to the tranformation algorithm.</summary>
        /// <remarks>The size in bytes of the input block to the tranformation algorithm.</remarks>
        private const int BlockLength = 64;

        /// <summary>4 32-bit words (interim result)</summary>
        private int[] _context = new int[4];

        /// <summary>Number of bytes processed so far mod.</summary>
        /// <remarks>Number of bytes processed so far mod. 2 power of 64.</remarks>
        private long _count;

        /// <summary>512 bits input buffer = 16 x 32-bit words holds until reaches 512 bits.</summary>
        /// <remarks>512 bits input buffer = 16 x 32-bit words holds until reaches 512 bits.</remarks>
        private byte[] _buffer = new byte[BlockLength];

        /// <summary>512 bits work buffer = 16 x 32-bit words</summary>
        private int[] _x = new int[16];

        public Md4()
        {
            // This file is currently unlocked (change this line if you lock the file)
            //
            // $Log: MD4.java,v $
            // Revision 1.2  1998/01/05 03:41:19  iang
            // Added references only.
            //
            // Revision 1.1.1.1  1997/11/03 22:36:56  hopwood
            // + Imported to CVS (tagged as 'start').
            //
            // Revision 0.1.0.0  1997/07/14  R. Naffah
            // + original version
            //
            // $Endlog$
            // MD4 specific object variables
            //...........................................................................
            //    = 512 / 8;
            // Constructors
            //...........................................................................
            EngineReset();
        }

        /// <summary>This constructor is here to implement cloneability of this class.</summary>
        /// <remarks>This constructor is here to implement cloneability of this class.</remarks>
        private Md4(Md4 md) : this()
        {
            _context = (int[])md._context.Clone();
            _buffer = (byte[])md._buffer.Clone();
            _count = md._count;
        }

        // Cloneable method implementation
        //...........................................................................
        /// <summary>Returns a copy of this MD object.</summary>
        /// <remarks>Returns a copy of this MD object.</remarks>
        public object Clone()
        {
            return new Md4(this);
        }

        // JCE methods
        //...........................................................................
        /// <summary>
        /// Resets this object disregarding any temporary data present at the
        /// time of the invocation of this call.
        /// </summary>
        /// <remarks>
        /// Resets this object disregarding any temporary data present at the
        /// time of the invocation of this call.
        /// </remarks>
        protected void EngineReset()
        {
            // initial values of MD4 i.e. A, B, C, D
            // as per rfc-1320; they are low-order byte first
            _context[0] = unchecked(0x67452301);
            _context[1] = unchecked((int)(0xEFCDAB89));
            _context[2] = unchecked((int)(0x98BADCFE));
            _context[3] = unchecked(0x10325476);
            _count = 0L;
            for (int i = 0; i < BlockLength; i++)
            {
                _buffer[i] = 0;
            }
        }

        /// <summary>Continues an MD4 message digest using the input byte.</summary>
        /// <remarks>Continues an MD4 message digest using the input byte.</remarks>
        protected void EngineUpdate(byte b)
        {
            // compute number of bytes still unhashed; ie. present in buffer
            int i = (int)(_count % BlockLength);
            _count++;
            // update number of bytes
            _buffer[i] = b;
            if (i == BlockLength - 1)
            {
                Transform(_buffer, 0);
            }
        }

        /// <summary>MD4 block update operation.</summary>
        /// <remarks>
        /// MD4 block update operation.
        /// <p>
        /// Continues an MD4 message digest operation, by filling the buffer,
        /// transform(ing) data in 512-bit message block(s), updating the variables
        /// context and count, and leaving (buffering) the remaining bytes in buffer
        /// for the next update or finish.
        /// </remarks>
        /// <param name="input">input block</param>
        /// <param name="offset">start of meaningful bytes in input</param>
        /// <param name="len">count of bytes in input block to consider</param>
        protected void EngineUpdate(byte[] input, int offset, int len)
        {
            // make sure we don't exceed input's allocated size/length
            if (offset < 0 || len < 0 || (long)offset + len > input.Length)
            {
                throw new IndexOutOfRangeException();
            }
            // compute number of bytes still unhashed; ie. present in buffer
            int bufferNdx = (int)(_count % BlockLength);
            _count += len;
            // update number of bytes
            int partLen = BlockLength - bufferNdx;
            int i = 0;
            if (len >= partLen)
            {
                Array.Copy(input, offset, _buffer, bufferNdx, partLen);
                Transform(_buffer, 0);
                for (i = partLen; i + BlockLength - 1 < len; i += BlockLength)
                {
                    Transform(input, offset + i);
                }
                bufferNdx = 0;
            }
            // buffer remaining input
            if (i < len)
            {
                Array.Copy(input, offset + i, _buffer, bufferNdx, len - i);
            }
        }

        /// <summary>
        /// Completes the hash computation by performing final operations such
        /// as padding.
        /// </summary>
        /// <remarks>
        /// Completes the hash computation by performing final operations such
        /// as padding. At the return of this engineDigest, the MD engine is
        /// reset.
        /// </remarks>
        /// <returns>the array of bytes for the resulting hash value.</returns>
        protected byte[] EngineDigest()
        {
            // pad output to 56 mod 64; as RFC1320 puts it: congruent to 448 mod 512
            int bufferNdx = (int)(_count % BlockLength);
            int padLen = (bufferNdx < 56) ? (56 - bufferNdx) : (120 - bufferNdx);
            // padding is alwas binary 1 followed by binary 0s
            byte[] tail = new byte[padLen + 8];
            tail[0] = unchecked(unchecked(0x80));
            // append length before final transform:
            // save number of bits, casting the long to an array of 8 bytes
            // save low-order byte first.
            for (int i = 0; i < 8; i++)
            {
                tail[padLen + i] = unchecked((byte)((long)(((ulong)(_count * 8)) >> (8 * i))));
            }
            EngineUpdate(tail, 0, tail.Length);
            byte[] result = new byte[16];
            // cast this MD4's context (array of 4 ints) into an array of 16 bytes.
            for (int i1 = 0; i1 < 4; i1++)
            {
                for (int j = 0; j < 4; j++)
                {
                    result[i1 * 4 + j] = unchecked((byte)((int)(((uint)_context[i1]) >> (8 * j))));
                }
            }
            // reset the engine
            EngineReset();
            return result;
        }

        // own methods
        //...........................................................................
        /// <summary>MD4 basic transformation.</summary>
        /// <remarks>
        /// MD4 basic transformation.
        /// <p>
        /// Transforms context based on 512 bits from input block starting
        /// from the offset'th byte.
        /// </remarks>
        /// <param name="block">input sub-array.</param>
        /// <param name="offset">starting position of sub-array.</param>
        private void Transform(byte[] block, int offset)
        {
            // encodes 64 bytes from input block into an array of 16 32-bit
            // entities. Use A as a temp var.
            for (int i = 0; i < 16; i++)
            {
                _x[i] = (block[offset++] & unchecked(0xFF)) | (block[offset++] & unchecked(
                    0xFF)) << 8 | (block[offset++] & unchecked(0xFF)) << 16 | (block[offset
                    ++] & unchecked(0xFF)) << 24;
            }
            int a = _context[0];
            int b = _context[1];
            int c = _context[2];
            int d = _context[3];
            a = Ff(a, b, c, d, _x[0], 3);
            d = Ff(d, a, b, c, _x[1], 7);
            c = Ff(c, d, a, b, _x[2], 11);
            b = Ff(b, c, d, a, _x[3], 19);
            a = Ff(a, b, c, d, _x[4], 3);
            d = Ff(d, a, b, c, _x[5], 7);
            c = Ff(c, d, a, b, _x[6], 11);
            b = Ff(b, c, d, a, _x[7], 19);
            a = Ff(a, b, c, d, _x[8], 3);
            d = Ff(d, a, b, c, _x[9], 7);
            c = Ff(c, d, a, b, _x[10], 11);
            b = Ff(b, c, d, a, _x[11], 19);
            a = Ff(a, b, c, d, _x[12], 3);
            d = Ff(d, a, b, c, _x[13], 7);
            c = Ff(c, d, a, b, _x[14], 11);
            b = Ff(b, c, d, a, _x[15], 19);
            a = Gg(a, b, c, d, _x[0], 3);
            d = Gg(d, a, b, c, _x[4], 5);
            c = Gg(c, d, a, b, _x[8], 9);
            b = Gg(b, c, d, a, _x[12], 13);
            a = Gg(a, b, c, d, _x[1], 3);
            d = Gg(d, a, b, c, _x[5], 5);
            c = Gg(c, d, a, b, _x[9], 9);
            b = Gg(b, c, d, a, _x[13], 13);
            a = Gg(a, b, c, d, _x[2], 3);
            d = Gg(d, a, b, c, _x[6], 5);
            c = Gg(c, d, a, b, _x[10], 9);
            b = Gg(b, c, d, a, _x[14], 13);
            a = Gg(a, b, c, d, _x[3], 3);
            d = Gg(d, a, b, c, _x[7], 5);
            c = Gg(c, d, a, b, _x[11], 9);
            b = Gg(b, c, d, a, _x[15], 13);
            a = Hh(a, b, c, d, _x[0], 3);
            d = Hh(d, a, b, c, _x[8], 9);
            c = Hh(c, d, a, b, _x[4], 11);
            b = Hh(b, c, d, a, _x[12], 15);
            a = Hh(a, b, c, d, _x[2], 3);
            d = Hh(d, a, b, c, _x[10], 9);
            c = Hh(c, d, a, b, _x[6], 11);
            b = Hh(b, c, d, a, _x[14], 15);
            a = Hh(a, b, c, d, _x[1], 3);
            d = Hh(d, a, b, c, _x[9], 9);
            c = Hh(c, d, a, b, _x[5], 11);
            b = Hh(b, c, d, a, _x[13], 15);
            a = Hh(a, b, c, d, _x[3], 3);
            d = Hh(d, a, b, c, _x[11], 9);
            c = Hh(c, d, a, b, _x[7], 11);
            b = Hh(b, c, d, a, _x[15], 15);
            _context[0] += a;
            _context[1] += b;
            _context[2] += c;
            _context[3] += d;
        }

        // The basic MD4 atomic functions.
        private int Ff(int a, int b, int c, int d, int x, int s)
        {
            int t = a + ((b & c) | (~b & d)) + x;
            return t << s | (int)(((uint)t) >> (32 - s));
        }

        private int Gg(int a, int b, int c, int d, int x, int s)
        {
            int t = a + ((b & (c | d)) | (c & d)) + x + unchecked(0x5A827999);
            return t << s | (int)(((uint)t) >> (32 - s));
        }

        private int Hh(int a, int b, int c, int d, int x, int s)
        {
            int t = a + (b ^ c ^ d) + x + unchecked(0x6ED9EBA1);
            return t << s | (int)(((uint)t) >> (32 - s));
        }

        public override byte[] Digest()
        {
            return EngineDigest();
        }

        public override int GetDigestLength()
        {
            return EngineDigest().Length;
        }

        public override void Reset()
        {
            EngineReset();
        }

        public override void Update(byte[] b)
        {
            EngineUpdate(b, 0, b.Length);
        }

        public override void Update(byte b)
        {
            EngineUpdate(b);
        }

        public override void Update(byte[] b, int offset, int len)
        {
            EngineUpdate(b, offset, len);
        }
    }
}
